JavaScripti dekoraatorid, metaandmed ja peegeldus: käitusaegne metaandmetele juurdepääs täiustatud funktsionaalsuse jaoks

JavaScript, arenedes kaugemale oma algsest skriptimise rollist, toetab nüüd keerukaid veebirakendusi ja serveripoolseid keskkondi. See areng nõuab keerukuse haldamiseks, hooldatavuse parandamiseks ja koodi taaskasutamise edendamiseks täiustatud programmeerimistehnikaid. Dekoraatorid, 2. etapi ECMAScripti ettepanek, koos metaandmete peegeldusega pakuvad võimsat mehhanismi nende eesmärkide saavutamiseks, võimaldades käitusaegset metaandmetele juurdepääsu ja aspektorienteeritud programmeerimise (AOP) paradigmasid.

Dekoraatorite mõistmine

Dekoraatorid on süntaktilise suhkru vorm, mis pakuvad lühikest ja deklareerivat viisi klasside, meetodite, omaduste või parameetrite käitumise muutmiseks või laiendamiseks. Need on funktsioonid, millele eelneb sümbol @ ja mis asetatakse vahetult enne elementi, mida nad kaunistavad. See võimaldab lisada ristlõike muresid, nagu logimine, valideerimine või autoriseerimine, ilma kaunistatud elementide põhiloogikat otseselt muutmata.

Mõelge lihtsale näitele. Kujutage ette, et peate logima iga kord, kui konkreetset meetodit kutsutakse. Ilma dekoraatoriteta peaksite logimisloogika käsitsi lisama igale meetodile. Dekoraatoritega saate luua @log dekoraatori ja rakendada seda meetoditele, mida soovite logida. See lähenemine hoiab logimisloogika põhimeetodi loogikast eraldi, parandades koodi loetavust ja hooldatavust.

Dekoraatorite tüübid

JavaScriptis on neli tüüpi dekoraatoreid, millest igaüks teenib erinevat eesmärki:

• Klassi dekoraatorid: Need dekoraatorid muudavad klassi konstruktorit. Neid saab kasutada uute omaduste, meetodite lisamiseks või olemasolevate muutmiseks.
• Meetodi dekoraatorid: Need dekoraatorid muudavad meetodi käitumist. Neid saab kasutada logimise, valideerimise või autoriseerimisloogika lisamiseks enne või pärast meetodi täitmist.
• Omaduse dekoraatorid: Need dekoraatorid muudavad omaduse kirjeldajat. Neid saab kasutada andmete sidumise, valideerimise või laiskuse initsialiseerimise rakendamiseks.
• Parameetri dekoraatorid: Need dekoraatorid pakuvad metaandmeid meetodi parameetrite kohta. Neid saab kasutada sõltuvuse süstimise või valideerimisloogika rakendamiseks parameetrite tüüpide või väärtuste põhjal.

Põhiline dekoraatori süntaks

Dekoraator on funktsioon, mis võtab ühe, kaks või kolm argumenti, olenevalt kaunistatud elemendi tüübist:

• Klassi dekoraator: Võtab argumendina klassi konstruktori.
• Meetodi dekoraator: Võtab kolm argumenti: sihtobjekti (kas konstruktorifunktsioon staatilise liikme jaoks või klassi prototüübi eksemplariliikme jaoks), liikme nime ja liikme omaduse kirjeldaja.
• Omaduse dekoraator: Võtab kaks argumenti: sihtobjekti ja omaduse nime.
• Parameetri dekoraator: Võtab kolm argumenti: sihtobjekti, meetodi nime ja parameetri indeksi meetodi parameetrite loendis.

Siin on näide lihtsast klassi dekoraatorist:

function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class Greeter {
  greeting: string;
  constructor(message: string) {
    this.greeting = message;
  }
  greet() {
    return "Tere, " + this.greeting;
  }
}

Selles näites rakendatakse @sealed dekoraatorit klassile Greeter. Funktsioon sealed külmutab nii konstruktori kui ka selle prototüübi, vältides edasisi muudatusi. See võib olla kasulik teatud klasside muutumatuse tagamiseks.

Metaandmete peegelduse jõud

Metaandmete peegeldus pakub viisi juurdepääsuks klasside, meetodite, omaduste ja parameetritega seotud metaandmetele käitusajal. See võimaldab võimsaid võimalusi, nagu sõltuvuse süstimine, serialiseerimine ja valideerimine. JavaScript iseenesest ei toeta peegeldust samal viisil nagu keeled nagu Java või C#. Kuid sellised teegid nagu reflect-metadata pakuvad seda funktsionaalsust.

Ron Bucktoni poolt välja töötatud teek reflect-metadata võimaldab teil lisada metaandmeid klassidele ja nende liikmetele, kasutades dekoraatoreid, ja seejärel neid metaandmeid käitusajal hankida. See võimaldab teil luua paindlikumaid ja konfigureeritavamaid rakendusi.

Reflect-metadata installimine ja importimine

Teegi reflect-metadata kasutamiseks peate selle esmalt installima, kasutades npm-i või yarn-i:

npm install reflect-metadata --save

Või kasutades yarni:

yarn add reflect-metadata

Seejärel peate selle oma projekti importima. TypeScriptis saate lisada järgmise rea oma peamise faili (nt index.ts või app.ts) ülaossa:

import 'reflect-metadata';

See impordilausung on ülioluline, kuna see täidab vajalikud Reflect API-d, mida kasutavad dekoraatorid ja metaandmete peegeldus. Kui unustate selle impordi, ei pruugi teie kood õigesti töötada ja tõenäoliselt ilmnevad käitusaja vead.

Metaandmete lisamine dekoraatoritega

Teek reflect-metadata pakub funktsiooni Reflect.defineMetadata objektidele metaandmete lisamiseks. Kuid metaandmete määratlemiseks on tavalisem ja mugavam kasutada dekoraatoreid. Dekoraatoritehas Reflect.metadata pakub lühikest viisi metaandmete määratlemiseks, kasutades dekoraatoreid.

Siin on näide:

import 'reflect-metadata';

const formatMetadataKey = Symbol("format");

function format(formatString: string) {
  return Reflect.metadata(formatMetadataKey, formatString);
}

function getFormat(target: any, propertyKey: string) {
  return Reflect.getMetadata(formatMetadataKey, target, propertyKey);
}

class Example {
  @format("Tere, %s")
  greeting: string = "Maailm";

  greet() {
    let formatString = getFormat(this, "greeting");
    return formatString.replace("%s", this.greeting);
  }
}

let example = new Example();
console.log(example.greet()); // Väljund: Tere, Maailm

Selles näites kasutatakse dekoraatorit @format, et seostada vormindusstringi "Tere, %s" klassi Example omadusega greeting. Funktsioon getFormat kasutab Reflect.getMetadata nende metaandmete hankimiseks käitusajal. Seejärel kasutab meetod greet neid metaandmeid tervitussõnumi vormindamiseks.

Reflect metaandmete API

Teek reflect-metadata pakub mitmeid funktsioone metaandmetega töötamiseks:

• Reflect.defineMetadata(metadataKey, metadataValue, target, propertyKey?): Lisab metaandmed objektile või omadusele.
• Reflect.getMetadata(metadataKey, target, propertyKey?): Hankib metaandmed objektist või omadusest.
• Reflect.hasMetadata(metadataKey, target, propertyKey?): Kontrollib, kas objektil või omadusel on metaandmed.
• Reflect.deleteMetadata(metadataKey, target, propertyKey?): Kustutab metaandmed objektist või omadusest.
• Reflect.getMetadataKeys(target, propertyKey?): Tagastab kõigi objektil või omadusel määratletud metaandmete võtmete massiivi.
• Reflect.getOwnMetadataKeys(target, propertyKey?): Tagastab kõigi objektil või omadusel otse määratletud metaandmete võtmete massiivi (välja arvatud päritud metaandmed).

Kasutusjuhud ja praktilised näited

Dekoraatoritel ja metaandmete peegeldusel on moodsas JavaScripti arenduses arvukalt rakendusi. Siin on mõned näited:

Sõltuvuse süstimine

Sõltuvuse süstimine (DI) on disainimuster, mis soodustab komponentide vahelist lõtva sidumist, pakkudes klassile sõltuvusi, mitte lastes klassil neid ise luua. Dekoraatoreid ja metaandmete peegeldust saab kasutada DI konteinerite rakendamiseks JavaScriptis.

Mõelge stsenaariumile, kus teil on UserService, mis sõltub UserRepository-st. Sõltuvuste määramiseks ja nende käitusajal lahendamiseks saate kasutada dekoraatoreid ja DI konteinerit.

import 'reflect-metadata';

const Injectable = (): ClassDecorator => {
  return (target: any) => {
    Reflect.defineMetadata('design:paramtypes', [], target);
  };
};

const Inject = (token: any): ParameterDecorator => {
  return (target: any, propertyKey: string | symbol, parameterIndex: number) => {
    let existingParameters: any[] = Reflect.getOwnMetadata('design:paramtypes', target, propertyKey) || [];
    existingParameters[parameterIndex] = token;
    Reflect.defineMetadata('design:paramtypes', existingParameters, target, propertyKey);
  };
};

class UserRepository {
  getUsers() {
    return ['kasutaja1', 'kasutaja2'];
  }
}

@Injectable()
class UserService {
  private userRepository: UserRepository;

  constructor(@Inject(UserRepository) userRepository: UserRepository) {
    this.userRepository = userRepository;
  }

  getUsers() {
    return this.userRepository.getUsers();
  }
}

// Lihtne DI konteiner
class Container {
  private static dependencies = new Map();

  static register(key: any, concrete: { new(...args: any[]): T }): void {
    Container.dependencies.set(key, concrete);
  }

  static resolve(key: any): T {
    const concrete = Container.dependencies.get(key);
    if (!concrete) {
      throw new Error(`Ei leitud seost ${key}`);
    }

    const paramtypes = Reflect.getMetadata('design:paramtypes', concrete) || [];
    const dependencies = paramtypes.map((param: any) => Container.resolve(param));
    return new concrete(...dependencies);
  }
}

// Sõltuvuste registreerimine
Container.register(UserRepository, UserRepository);
Container.register(UserService, UserService);

// Lahenda UserService
const userService = Container.resolve(UserService);

console.log(userService.getUsers()); // Väljund: ['kasutaja1', 'kasutaja2']

Selles näites märgistab dekoraator @Injectable klasse, mida saab süstida, ja dekoraator @Inject määrab konstruktori sõltuvused. Klass Container toimib lihtsa DI konteinerina, lahendades sõltuvusi dekoraatorite poolt määratletud metaandmete põhjal.

Serialiseerimine ja deserialiseerimine

Dekoraatoreid ja metaandmete peegeldust saab kasutada objektide serialiseerimis- ja deserialiseerimisprotsessi kohandamiseks. See võib olla kasulik objektide kaardistamisel erinevate andmevormingutele, näiteks JSON või XML, või andmete valideerimisel enne deserialiseerimist.

Mõelge stsenaariumile, kus soovite klassi JSON-i serialiseerida, kuid soovite teatud omadused välja jätta või ümber nimetada. Saate kasutada dekoraatoreid serialiseerimisreeglite määramiseks ja seejärel kasutada metaandmeid serialiseerimise teostamiseks.

import 'reflect-metadata';

const Exclude = (): PropertyDecorator => {
  return (target: any, propertyKey: string | symbol) => {
    Reflect.defineMetadata('serialize:exclude', true, target, propertyKey);
  };
};

const Rename = (newName: string): PropertyDecorator => {
  return (target: any, propertyKey: string | symbol) => {
    Reflect.defineMetadata('serialize:rename', newName, target, propertyKey);
  };
};

class User {
  @Exclude()
  id: number;

  @Rename('fullName')
  name: string;

  email: string;

  constructor(id: number, name: string, email: string) {
    this.id = id;
    this.name = name;
    this.email = email;
  }
}

function serialize(obj: any): string {
  const serialized: any = {};
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const exclude = Reflect.getMetadata('serialize:exclude', obj, key);
      if (exclude) {
        continue;
      }
      const rename = Reflect.getMetadata('serialize:rename', obj, key);
      const newKey = rename || key;
      serialized[newKey] = obj[key];
    }
  }
  return JSON.stringify(serialized);
}

const user = new User(1, 'John Doe', 'john.doe@example.com');
const serializedUser = serialize(user);
console.log(serializedUser); // Väljund: {"fullName":"John Doe","email":"john.doe@example.com"}

Selles näites märgib dekoraator @Exclude omaduse id serialiseerimisest välja ja dekoraator @Rename nimetab omaduse name ümber väärtuseks fullName. Funktsioon serialize kasutab serialiseerimise teostamiseks metaandmeid vastavalt määratletud reeglitele.

Valideerimine

Dekoraatoreid ja metaandmete peegeldust saab kasutada klasside ja omaduste valideerimisloogika rakendamiseks. See võib olla kasulik tagamaks, et andmed vastavad teatud kriteeriumidele enne nende töötlemist või salvestamist.

Mõelge stsenaariumile, kus soovite valideerida, et omadus ei ole tühi või see vastab konkreetsele regulaaravaldisele. Saate kasutada dekoraatoreid valideerimisreeglite määramiseks ja seejärel kasutada metaandmeid valideerimise teostamiseks.

import 'reflect-metadata';

const Required = (): PropertyDecorator => {
  return (target: any, propertyKey: string | symbol) => {
    Reflect.defineMetadata('validate:required', true, target, propertyKey);
  };
};

const Pattern = (regex: RegExp): PropertyDecorator => {
  return (target: any, propertyKey: string | symbol) => {
    Reflect.defineMetadata('validate:pattern', regex, target, propertyKey);
  };
};

class Product {
  @Required()
  name: string;

  @Pattern(/^\d+$/)
  price: string;

  constructor(name: string, price: string) {
    this.name = name;
    this.price = price;
  }
}

function validate(obj: any): string[] {
  const errors: string[] = [];
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const required = Reflect.getMetadata('validate:required', obj, key);
      if (required && !obj[key]) {
        errors.push(`${key} on nõutav`);
      }
      const pattern = Reflect.getMetadata('validate:pattern', obj, key);
      if (pattern && !pattern.test(obj[key])) {
        errors.push(`${key} peab vastama ${pattern}`);
      }
    }
  }
  return errors;
}

const product = new Product('', 'abc');
const errors = validate(product);
console.log(errors); // Väljund: ["nimi on nõutav", "hind peab vastama /^\d+$/"]

Selles näites märgistab dekoraator @Required omaduse name nõutavaks ja dekoraator @Pattern määrab regulaaravaldise, millele omadus price peab vastama. Funktsioon validate kasutab valideerimise teostamiseks metaandmeid ja tagastab vigade massiivi.

AOP (Aspektorienteeritud programmeerimine)

AOP on programmeerimisparadigma, mille eesmärk on suurendada moodulisust, võimaldades ristlõike mured eraldamist. Dekoraatorid sobivad loomulikult AOP stsenaariumidele. Näiteks logimist, auditeerimist ja turvakontrolle saab rakendada dekoraatoritena ja rakendada meetoditele, muutmata meetodi põhiloogikat.

Näide: Logimisaspekti rakendamine, kasutades dekoraatoreid.

import 'reflect-metadata';

function LogMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`Sisenev meetod: ${propertyKey} argumentidega: ${JSON.stringify(args)}`);
    const result = originalMethod.apply(this, args);
    console.log(`Väljuv meetod: ${propertyKey} tulemusega: ${result}`);
    return result;
  };

  return descriptor;
}

class Calculator {
  @LogMethod
  add(a: number, b: number): number {
    return a + b;
  }

  @LogMethod
  subtract(a: number, b: number): number {
    return a - b;
  }
}

const calculator = new Calculator();
calculator.add(5, 3);
calculator.subtract(10, 2);

// Väljund:
// Sisenev meetod: add argumentidega: [5,3]
// Väljuv meetod: add tulemusega: 8
// Sisenev meetod: subtract argumentidega: [10,2]
// Väljuv meetod: subtract tulemusega: 8

See kood logib meetodite add ja subtract sisenemis- ja väljumispunktid, eraldades tõhusalt logimise mure kalkulaatori põhifunktsionaalsusest.

Dekoraatorite ja metaandmete peegelduse kasutamise eelised

Dekoraatorite ja metaandmete peegelduse kasutamine JavaScriptis pakub mitmeid eeliseid:

• Parem koodi loetavus: Dekoraatorid pakuvad lühikest ja deklareerivat viisi klasside ja nende liikmete käitumise muutmiseks või laiendamiseks, muutes koodi hõlpsamini loetavaks ja arusaadavaks.
• Suurenenud moodulisus: Dekoraatorid edendavad murede eraldamist, võimaldades teil ristlõike muresid isoleerida ja koodi dubleerimist vältida.
• Täiustatud hooldatavus: Murede eraldamise ja koodi dubleerimise vähendamise abil muudavad dekoraatorid koodi hõlpsamini hooldatavaks ja värskendatavaks.
• Suurem paindlikkus: Metaandmete peegeldus võimaldab teil käitusajal metaandmetele juurde pääseda, võimaldades teil luua paindlikumaid ja konfigureeritavamaid rakendusi.
• AOP lubamine: Dekoraatorid hõlbustavad AOP-d, võimaldades teil rakendada meetoditele aspekte, muutmata nende põhiloogikat.

Väljakutsed ja kaalutlused

Kuigi dekoraatorid ja metaandmete peegeldus pakuvad palju eeliseid, on ka mõned väljakutsed ja kaalutlused, mida meeles pidada:

• Jõudluse lisakulu: Metaandmete peegeldus võib põhjustada teatud jõudluse lisakulu, eriti kui seda kasutatakse ulatuslikult.
• Keerukus: Dekoraatorite ja metaandmete peegelduse mõistmine ja kasutamine nõuab sügavamat arusaamist JavaScriptist ja teegist reflect-metadata.
• Silumine: Dekoraatoreid ja metaandmete peegeldust kasutava koodi silumine võib olla keerulisem kui traditsioonilise koodi silumine.
• Ühilduvus: Dekoraatorid on endiselt 2. etapi ECMAScripti ettepanek ja nende rakendamine võib JavaScripti erinevates keskkondades erineda. TypeScript pakub suurepärast tuge, kuid pidage meeles, et käitusaja polüfill on hädavajalik.

Parimad tavad

Dekoraatorite ja metaandmete peegelduse tõhusaks kasutamiseks kaaluge järgmisi parimaid tavasid:

• Kasutage dekoraatoreid säästlikult: Kasutage dekoraatoreid ainult siis, kui need pakuvad selget kasu koodi loetavuse, moodulisuse või hooldatavuse osas. Vältige dekoraatorite liigset kasutamist, kuna need võivad muuta koodi keerulisemaks ja raskemini silmatavaks.
• Hoidke dekoraatorid lihtsad: Hoidke dekoraatorid keskendunud ühele vastutusele. Vältige keerukate dekoraatorite loomist, mis täidavad mitut ülesannet.
• Dokumenteerige dekoraatoreid: Dokumenteerige selgelt iga dekoraatori eesmärk ja kasutus. See hõlbustab teiste arendajate jaoks teie koodi mõistmist ja kasutamist.
• Testige dekoraatoreid põhjalikult: Testige oma dekoraatoreid põhjalikult, et tagada nende õige toimimine ja et need ei tekitaks ootamatuid kõrvalmõjusid.
• Kasutage ühtlast nimetamisviisi: Võtke koodi loetavuse parandamiseks kasutusele dekoraatorite järjepidev nimetamisviis. Näiteks võiksite lisada kõigi dekoraatorite nimede ette sümboli @.

Alternatiivid dekoraatoritele

Kuigi dekoraatorid pakuvad võimsat mehhanismi funktsionaalsuse lisamiseks klassidele ja meetoditele, on olemas alternatiivsed lähenemisviisid, mida saab kasutada olukordades, kus dekoraatorid pole saadaval või sobivad.

Kõrgemad järgu funktsioonid

Kõrgemad järgu funktsioonid (HOF-id) on funktsioonid, mis võtavad teisi funktsioone argumentidena või tagastavad funktsioone tulemustena. HOF-e saab kasutada paljude samade mustrite rakendamiseks nagu dekoraatorid, näiteks logimine, valideerimine ja autoriseerimine.

Segud

Segud on viis funktsionaalsuse lisamiseks klassidele, komponeerides neid teiste klassidega. Segusid saab kasutada koodi jagamiseks mitme klassi vahel ja koodi dubleerimise vältimiseks.

Ahvide paigaldamine

Ahvide paigaldamine on tegevus, millega muudetakse olemasoleva koodi käitumist käitusajal. Ahvide paigaldamist saab kasutada funktsionaalsuse lisamiseks klassidele ja meetoditele, muutmata nende lähtekoodi. Kuid ahvide paigaldamine võib olla ohtlik ja seda tuleks kasutada ettevaatusega, kuna see võib põhjustada ootamatuid kõrvalmõjusid ja muuta koodi hooldamist keerulisemaks.

Järeldus

JavaScripti dekoraatorid koos metaandmete peegeldusega pakuvad võimsaid tööriistu koodi moodulisuse, hooldatavuse ja paindlikkuse suurendamiseks. Võimaldades käitusaegset metaandmetele juurdepääsu, avavad need arenenud funktsionaalsused nagu sõltuvuse süstimine, serialiseerimine, valideerimine ja AOP. Kuigi on arvestamist väärt väljakutseid, nagu jõudluse lisakulu ja keerukus, kaaluvad dekoraatorite ja metaandmete peegelduse kasutamise eelised sageli üles puudused. Parimate tavade järgimisega ja alternatiivide mõistmisega saavad arendajad neid tehnikaid tõhusalt ära kasutada, et luua vastupidavamaid ja skaleeritavamaid JavaScripti rakendusi. Kuna JavaScript areneb jätkuvalt, muutuvad dekoraatorid ja metaandmete peegeldus tõenäoliselt üha olulisemaks keerukuse haldamisel ja koodi taaskasutamise edendamisel kaasaegses veebiarenduses.

See artikkel annab põhjaliku ülevaate JavaScripti dekoraatoritest, metaandmetest ja peegeldusest, hõlmates nende süntaksit, kasutusjuhte ja parimaid tavasid. Neid mõisteid mõistes saavad arendajad JavaScripti täieliku potentsiaali avada ja võimsamaid ja hooldatavamaid rakendusi luua.

Neid tehnikaid omaks võttes saavad arendajad kogu maailmas panustada moodulisemasse, hooldatavamasse ja skaleeritavamasse JavaScripti ökosüsteemi.